

let str: string // 这里一定要写小写
const a = {
    name: "·1343", // 这里为什么不能
    age: 123
}
a.age = 18
a.name = "jaha11"
let b: "hellow" // 字面量类型 只能是hellow  b="helllow1" 会报错
let c: String;
// c = new String('hekel');
let d: any; // any 任意类型 可以赋值给认以类型
let e: unknown  // 不知道是什么类型，目前不能确定的 ,类型安全（需要强转）
let f: never // never  不能赋值给任何类型 主要用于限制函数的返回的 一般不用
let g: void // void  表示没有返回值 其实转为js就是 undefined, 语义上不同 就比如
let h: object // 存储的是非原始类型
let i = Object //  存储的是类型是可以调用到Object方法的类型 （除了 null 和 undefined）


/*断言 (类型判断 )*/
// e = new String("我是Eya")
if (typeof e == 'string') {
    c = e.toLowerCase()
}
if (e instanceof Object) {
    c = e.toString() + "object"
}

// c = <string>e   e as string


console.log("赋值之后的值是" + c)


/*ue: A function returning never cannot have a reachable end point.*/


function function4(): void {

    return undefined
}

function function1(): void {

    return
}

function function2(): void {


}

let qq: undefined

function function3(): undefined {


    return qq

}

console.log("函数的返回值" + function4())
/*
   1.静态类型检查
   2.将ts变为js  npm i typescript -g    tsc index
                自动化编译  tsc  --init  -----------> tsconfig.json
                          tsc   --watch

   3. 类型声明 类型推断
      类型 8 （number string boolean object null undefine bitint symbol）+ 6 （any void truple enum  never unknown）



*
*
* */


// 4. 声明一个对象类型

let person: {
    name: String,
    age?: number ,
    [key:string]:any
}

// 5. 声明一个函数类型

let count:(a:number,b:number)=>number
count = (a,b)=>{return a+b}

// 6.声明一个数组类型
let arr1:number[]
let  arr2:Array<string>
let  arr3:Array<number>


// 6.turple 元组 （不是关键字） （固定类型，固定长度） 特殊的数据类型
let arr4:[string,number]  // 元组
let arr5:[string,number?]  // 元组
let arr6:[string,...string[]]  // 元组


// 7.枚举 enum
enum Color {
    red,
    white,
     blue
}
console.log("Color "+Color.red.valueOf())
console.log("Color "+Color.red)


// 8. type 别名

type Status =number|string // 联合类型
type Gender ='男'|'女'

type  Area ={
    height:number,
    width:number
}

type  Address={
    num:number,
    cell:number,
    room:string
}

type  House= Area & Address // 交叉类型

let house:House={
    height:10,
    width:20,
    num:1,
    cell:2,
    room:"1-2-1"
}

// 使用 type 进行类型声明限制函数的返回值为void时，typescript 不进行void 强制限制检查，是为兼容 ladama 表达式


// 9. 复习类相关的   属性修饰符 public private protected readonly static

class Person{
    private   name:string
    age:number
    constructor(name:string,age:number) {
        this.name = name
        this.age = age
    }
     speak(): void{
         console.log("I am a Person")
    }
}

class PersonSimple{

    /*类似 kotlin*/
    constructor(public name:string,public age:number) {

    }
    speak(): void{
        console.log("I am a Person")
    }
}

class Student extends Person{
    constructor(name: string, age: number) {
        super(name, age)
    }
   override speak(): void {
        console.log("I am a student")
    }
}



// 10 抽象类
abstract class Animal{
    abstract speak():void
}
class Dog extends Animal{
    speak(): void {
        console.log("I am a dog")
    }
}

// 11 接口
interface PersonInterface{
    name:string
    age:number
    speak():void

}
class PersonInterfaceImpl implements PersonInterface{
    name: string="PersonInterfaceImpl"
    age: number=18
    addPro:number=10 //
    speak(): void {
        console.log("I am a PersonInterfaceImpl")
    }
}
// 这里相当于 类型定义
let noNameImpl:PersonInterface={
    name:"noNameImpl",
    age:18,
    // addPro:number=10, // 这里不能添加
    speak(): void {
        console.log("I am a noNameImpl")
    }
}

// 11 泛型  (泛型函数  泛型接口  泛型类)
function getArray<T>(value:T,length:number):T[]{
    return new Array<T>(length).fill(value)
}
getArray<number>(1,10)
getArray<String>("哈哈",10)


//12 类型声明文件- 为现有的javascript代码提供类型信息
import {add} from './demo.js'
add(1,2)

// 13 装饰器

 /* 1. 类装饰器*/


